home *** CD-ROM | disk | FTP | other *** search
/ MacWorld 1999 January - Disc 2 / Macworld (1999-01) (Disk 2).dmg / Serious Demos / Symbolic Composer 4.2 / Environment / Projects / Neurons / Random Rule Neurons < prev    next >
Lisp/Scheme  |  1998-10-26  |  4KB  |  109 lines
  1. ; Random Rule Oscillator 'noisy neuron'
  2.  
  3. ; Here a random rule oscillator is defined, and a couple of
  4. ; other neurons for further generating 2nd and 3rd melody lines.
  5. ; Use this as guidelines on how to define neural oscillators.
  6. ; Use melody,1 melody2 and melody3 to define instrument symbols.
  7.  
  8. ; Perhaps the simpliest way to make a permanently oscillating
  9. ; neuron is to use random rules, like in the following. When 
  10. ; experimenting with different pick-random values, or when 
  11. ; extending the rules, keep in mind that the outputs must fall 
  12. ; in the range of input rules can handle, and if not then 
  13. ; otherwise option must return the output in the input range.
  14.  
  15. (defun feedback-neuron (name n inputs)
  16.   (let ((out nil) (collect nil))
  17.     (dotimes (i n)
  18.       (setq out (apply 'run-neuron (append (list name) inputs)))
  19.       (push out collect)
  20.       (setq inputs (append (cdr inputs) (list out))))
  21.     (nreverse collect)))
  22.  
  23. (defun pack-name (a b)
  24.   (compress (append (explode a) '(-) (explode b))))
  25.  
  26. (defun seq (&optional name sequence)
  27.   (let ((out nil)
  28.         (counter nil))
  29.     (cond (sequence
  30.            (cond ((equal sequence :reset)
  31.                   (set (pack-name 'counter name) 0))
  32.                  (t (set (pack-name 'seq name) (vector-to-list sequence))
  33.                     (set (pack-name 'counter name) 0)))
  34.            t)
  35.           (t (setq counter (eval (pack-name 'counter name)))
  36.              (setq out (nth (mod counter (length (eval (pack-name 'seq name)))) 
  37.                             (eval (pack-name 'seq name))))
  38.              (setq counter (1+ counter))
  39.              (set (pack-name 'counter name) counter)
  40.              out))))
  41.     
  42. (def-neuron random-rule
  43.   (in 1 'a) (pick-random '(a b))
  44.   (in 1 'b) (pick-random '(-b -c))
  45.   (otherwise (pick-random '(a b)))
  46. )
  47.  
  48. ; Examine this in the visualizer. Use flatten to get rid of 
  49. ; the sublists. The oscillations have quite interesting look.
  50.  
  51. ; (flatten (feedback-neuron 'random-rule 10 '((a b c))))
  52. ; --> (b -c b -b b -c b -b b -b a -b a b a b -c a -c b a b -b a -c a a a a a)
  53.  
  54. ; To make rests, try the following:
  55.  
  56. (def-neuron random-rule
  57.   (in 1 'a) (pick-random '(a b))
  58.   (in 1 'b) (pick-random '(-b =))
  59.   (otherwise (pick-random '(a b)))
  60. )
  61.  
  62. ; (flatten (feedback-neuron 'random-rule 10 '((a b c))))
  63. ; --> (a = b a b = b -b b -b a = b b a = -b b b b = = = a b a a = b a)
  64.  
  65. ; Parallel Neural Lines
  66.  
  67. ; Random-rule neuron can be used as a 'clock signal' to drive
  68. ; the other neurons. This is accomplished in this way:
  69.  
  70. (setq melody1 (flatten (feedback-neuron 'random-rule 10 '((a b c)))))
  71. ; --> (a -b b b b = = -b a b a b = a -b b a b -b b -b b -b b -b a -b b a a)
  72.  
  73. ; Now, we want to add 2 more parallel lines to this neural pattern,
  74. ; so that all of the patterns obey a consistent set of rules. First
  75. ; generate the second line. This neuron finds series of aa, bb and
  76. ; ab. There is some randomness if these patterns are not found, and
  77. ; the output is picked random. Notice the multiple rests = = =. This
  78. ; ables to determine that the rests have 3/4 possibility to get
  79. ; selected resulting in a pattern with more rests.
  80.  
  81. (def-neuron second-line
  82.   (and (in 1 'a) (in 1 'a -1)) 'a
  83.   (and (in 1 'b) (in 1 'b -1)) 'b
  84.   (and (in 1 'a) (in 1 'b -1)) 'c
  85.   (otherwise (pick-random '(= = = -b)))
  86. )
  87.  
  88. (setq melody2 (run-neuron 'second-line melody1))
  89.  
  90. ; To add third line define one more neuron, and make it examine what
  91. ; is happening in both within each input line, and what is happening
  92. ; in parallel between the inputs.
  93.  
  94. (def-neuron third-line
  95.   (and (in 1 'b) (in 2 'b)) 'a
  96.   (and (in 1 'a) (in 2 'a)) 'b
  97.   (or (and (in 1 'b) (in 1 '-b -1))
  98.       (and (in 1 '-b) (in 1 'b -1))) (pick-random '(c d))
  99.   (otherwise (pick-random '(=)))
  100. )
  101.  
  102. (setq melody3 (run-neuron 'third-line melody1 melody2))
  103.  
  104. ; Use melody1, melody2, melody3 to define instruments. Redefine
  105. ; neuron rules to get more specific behaviour. The example shows
  106. ; just the basic principles of constructing neurons.
  107.  
  108. ; here comes your code
  109. ; kjhkjhkjhkjhkjhkjhkjhkjhkjh